#Какое утверждение верно относительно использования ключевого слова await в Python?
#await приостанавливает выполнение асинхронной функции до завершения ожидаемой операции.
######################################################
#С какими типами объектов может использоваться await?
#С объектами, допускающими ожидание. - awaitable объекты - корутины, футуры и таски
#########################################################
#Что произойдет, если использовать await с синхронной функцией?
#Произойдет ошибка TypeError
########################################################
#Как await влияет на выполнение программы при работе с асинхронными операциями?
#Приостанавливает выполнение текущей корутины, позволяя циклу событий обработать другие задачи.
##########################################################
#Что будет если в функции ожидаемой с await возникнет исключение, которое не будет обработано? 
#await также выбросит это исключение.
#####################################################
#Как await влияет на возвращаемые значения асинхронных функций?
#await позволяет получить непосредственное возвращаемое значение из асинхронной функции.
######################################
#Можно ли использовать await внутри циклов в асинхронных функциях?
# import asyncio


# async def fetch_data(simulation_delay: int, source: str) -> str:
#     await asyncio.sleep(simulation_delay)
#     return f"Данные из {source} получены"


# async def main():
#     sources = ["Источник 1", "Источник 2", "Источник 3"]  # Список источников данных
#     for source in sources:

#         # Использование await внутри цикла для ожидания завершения каждой итерации
#         data = await fetch_data(1, source)  # Предположим, что каждый запрос занимает 1 секунду
#         print(data)  # Вывод результата после получения данных


# asyncio.run(main())

#Да, await может использоваться внутри асинхронных циклов для ожидания завершения каждой итерации.
#Что делает следующий код?
# import asyncio

# async def task_one():
#     await asyncio.sleep(2)
#     return "Задача 1 завершена"

# async def task_two():
#     await asyncio.sleep(1)
#     return "Задача 2 завершена"

# async def main():
#     result_one = await task_one()
#     result_two = await task_two()
#     print(result_one, result_two)

# asyncio.run(main())
#Выполняет task_one и task_two последовательно, сначала дожидаясь завершения task_one.
#  В данном коде task_one и task_two выполняются последовательно из-за использования await для каждой задачи по отдельности.
# Это означает, что выполнение task_two начнется только после завершения task_one, что приводит к последовательному выполнению,
# а не параллельному.
###############
# import asyncio

# async def task1():
#     await asyncio.sleep(1)
#     print("Привет из корутины task1")

# async def task2():
#     await asyncio.sleep(1)
#     print("Привет из корутины task2")

# async def main():
#     await asyncio.create_task(task1())
#     await asyncio.create_task(task2())

# asyncio.run(main())
##################################################
# import asyncio

# async def task1():
#     print("Начинаем задачу 1")
#     await asyncio.sleep(1)
#     print("Привет из корутины task1")
#     await asyncio.sleep(1)
#     print("Задача 1 завершилась")

# async def task2():
#     print("Начинаем задачу 2")
#     await asyncio.sleep(2)
#     print("Привет из корутины task2")
#     await asyncio.sleep(2)
#     print("Задача 2 завершилась")

# async def task3():
#     print("Начинаем задачу 3")
#     await asyncio.sleep(3)
#     print("Привет из корутины task3")
#     await asyncio.sleep(3)
#     print("Задача 3 завершилась")

# async def main():
#     task_1 = asyncio.create_task(task1())
#     task_2 = asyncio.create_task(task2())
#     task_3 = asyncio.create_task(task3())

#     await task_1
#     await task_2
#     await task_3

# asyncio.run(main())
#####################################
import asyncio

async def compute_square(x):
    print(f"Вычисляем квадрат числа: {x}")
    await asyncio.sleep(1)  # Имитация длительной операции
    return x * x

async def main():
    # Создаём и запускаем задачи
    tasks = [asyncio.create_task(compute_square(i)) for i in range(10)]
    # Ожидаем завершения всех задач и собираем результаты

    for result in tasks:
        print(f"Результат: {await result}")

asyncio.run(main())